package com.qf.business.course.core.controller;

import com.qf.business.course.core.service.CourseTypeGuigeService;
import com.qf.business.course.core.service.CourseTypeService;
import com.qf.commons.data.result.R;
import com.qf.data.course.dto.CourseGuigeDto;
import com.qf.data.course.entity.CourseType;
import com.qf.data.course.entity.CourseTypeTreeNode;
import com.qf.data.course.vo.input.TypeGuigesInput;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/course/type")
@Slf4j
public class CourseTypeController {

    @Autowired
    private CourseTypeService courseTypeService;

    @Autowired
    private CourseTypeGuigeService courseTypeGuigeService;

    /**
     * 根据树形结构查询分类的列表
     * @return
     */
    @RequestMapping("/treeList")
    public R queryTreeList(){
        //查询出所有的课程分类列表
        List<CourseType> courseTypes = courseTypeService.list();

        //最终需要的结果
        //  TreeNode - 一级分类
        //      chlidren - 二级分类TreeNode
        //                         chlidren - 三级分类
        List<CourseTypeTreeNode> typeTreeNodes = new ArrayList<>();
        //Map集合  id TreeNode
        Map<Integer, CourseTypeTreeNode> typeTreeNodeMap = new HashMap<>();

        for (CourseType courseType : courseTypes) {
            //将课程分类的对象-> 树形结构的节点对象
            CourseTypeTreeNode treeNode = new CourseTypeTreeNode()
                    .setId(courseType.getId())
                    .setLabel(courseType.getTname())
                    .setLevel(courseType.getStatus());

            if (courseType.getPid() == null){
                //一级分类
                //添加到List集合中
                typeTreeNodes.add(treeNode);
            } else {
                //找到它的上级分类
                CourseTypeTreeNode parentTreeNode = typeTreeNodeMap.get(courseType.getPid());
                parentTreeNode.addNode(treeNode);
            }

            //放入Map集合
            typeTreeNodeMap.put(courseType.getId(), treeNode);
        }

        return R.create(typeTreeNodes);
    }

    /**
     * 新增课程分类
     * @return
     */
    @RequestMapping("/insert")
    public R insert(CourseType courseType){
        courseTypeService.save(courseType);
        return R.create("succ");
    }

    /**
     * 修改课程分类 和 规格之间的关联关系
     * @return
     */
    @RequestMapping("/updateGuiges")
    public R updateGuiges(TypeGuigesInput guigesInput){
        log.debug("[update type guiges] 设置分类的规格信息 - {}", guigesInput);
        courseTypeService.updateTypeGuiges(guigesInput);
        return R.create(null);
    }

    /**
     * 查询课程分类 下已经关联的规格id列表
     * @return 只需要返回关联的规格id列表 [1,2,3]
     */
    @RequestMapping("/guigeSelected")
    public R guigeSelected(Integer tid){
        List<Integer> gids = courseTypeGuigeService.query()
                .eq("tid", tid).list().stream().map(courseTypeGuige -> courseTypeGuige.getGid())
                .collect(Collectors.toList());
        return R.create(gids);
    }

    /**
     * 查询课程分类 下已经关联的规格列表
     * @param tid
     * @return
     */
    @RequestMapping("/guigeListSelected")
    public R guigeListSelected(Integer tid){
        List<CourseGuigeDto> courseGuigeDtos = courseTypeGuigeService.queryGuigesByTid(tid);
        log.debug("[query course guiges] 查询指定课程的规格列表 - {}", courseGuigeDtos);
        return R.create(courseGuigeDtos);
    }

    /**
     * 查询所有的一级分类
     * @return
     */
    @RequestMapping("/queryOneType")
    public R queryOneType(){
        List<CourseType> types = courseTypeService.query().eq("status", 1).list();
        return R.create(types);
    }
}